const express = require('express');
const router = express.Router();
const jwt = require('jsonwebtoken');
const axios = require('axios');
const crypto = require('crypto');
const { verifyToken } = require('../middlewares/auth');

// 生成随机用户ID
// 使用时间戳和随机数生成唯一的用户ID，并进行SHA-256哈希处理
const generateUserId = () => {
  const timestamp = Date.now().toString();
  const random = Math.floor(Math.random() * 1000000).toString().padStart(6, '0');
  const hash = crypto.createHash('sha256').update(timestamp + random).digest('hex');
  // 取前12位十六进制数，确保生成的数字在JavaScript安全整数范围内
  const maxSafeIntHex = '1fffffffffffff'; // JavaScript最大安全整数的十六进制表示
  const id = BigInt('0x' + hash.substr(0, 12));
  // 如果生成的ID大于最大安全整数，则对其取模
  return (id % BigInt('0x' + maxSafeIntHex)).toString();
};

// 微信小程序登录路由
// 处理微信小程序的登录请求，获取用户openid并生成JWT token
router.post('/login/wechat', async (req, res) => {
  try {
    // 验证请求参数
    const { code } = req.body;
    if (!code) {
      return res.status(400).json({ error: '缺少code参数' });
    }

    // 调用微信登录API获取openid
    const response = await axios.get(
      `https://api.weixin.qq.com/sns/jscode2session?appid=${process.env.WECHAT_APPID}&secret=${process.env.WECHAT_SECRET}&js_code=${code}&grant_type=authorization_code`
    );

    // 处理微信API返回的错误
    if (response.data.errcode) {
      return res.status(400).json({ error: '微信登录失败：' + response.data.errmsg });
    }

    const openid = response.data.openid;

    // 查找或创建用户记录
    const [existingUser] = await req.db.execute(
      'SELECT * FROM user_info WHERE openid = ?',
      [openid]
    );

    let userId;
    if (!existingUser || existingUser.length === 0) {
      // 创建新用户，设置初始查询次数为10次
      userId = generateUserId();
      const token = jwt.sign({ userId }, process.env.JWT_SECRET);
      await req.db.execute(
        'INSERT INTO user_info (id, openid, token, remaining_queries) VALUES (?, ?, ?, ?)',
        [userId, openid, token, 10]
      );
    } else {
      userId = existingUser[0].id;
    }

    // 生成新的JWT token并更新到数据库
    const token = jwt.sign({ userId }, process.env.JWT_SECRET);
    await req.db.execute(
      'UPDATE user_info SET token = ? WHERE id = ?',
      [token, userId]
    );

    res.json({ token });
  } catch (error) {
    console.error('登录错误：', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});

// 支付宝小程序登录路由
// 处理支付宝小程序的登录请求，获取用户user_id并生成JWT token
router.post('/login/alipay', async (req, res) => {
  try {
    // 验证请求参数
    const { code } = req.body;
    if (!code) {
      return res.status(400).json({ error: '缺少code参数' });
    }

    // 调用支付宝登录API获取user_id
    const response = await axios.get(
      `https://openapi.alipay.com/gateway.do?app_id=${process.env.ALIPAY_APPID}&method=alipay.system.oauth.token&format=JSON&charset=utf-8&sign_type=RSA2&timestamp=${new Date().toISOString()}&version=1.0&code=${code}&grant_type=authorization_code`
    );

    // 处理支付宝API返回的错误
    if (!response.data.user_id) {
      return res.status(400).json({ error: '支付宝登录失败' });
    }

    const openid = response.data.user_id;

    // 查找或创建用户记录
    const [existingUser] = await req.db.execute(
      'SELECT * FROM user_info WHERE openid = ?',
      [openid]
    );

    let userId;
    if (!existingUser || existingUser.length === 0) {
      // 创建新用户，设置初始查询次数为10次
      userId = generateUserId();
      const token = jwt.sign({ userId }, process.env.JWT_SECRET);
      await req.db.execute(
        'INSERT INTO user_info (id, openid, token, remaining_queries) VALUES (?, ?, ?, ?)',
        [userId, openid, token, 10]
      );
    } else {
      userId = existingUser[0].id;
    }

    // 生成新的JWT token并更新到数据库
    const token = jwt.sign({ userId }, process.env.JWT_SECRET);
    await req.db.execute(
      'UPDATE user_info SET token = ? WHERE id = ?',
      [token, userId]
    );

    res.json({ token });
  } catch (error) {
    console.error('登录错误：', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});

// 分享奖励接口
// 处理用户分享后的奖励，增加分享次数和剩余查询次数
router.post('/share', verifyToken, async (req, res) => {
  try {
    // 更新用户分享次数和剩余查询次数
    await req.db.execute(
      'UPDATE user_info SET share_count = share_count + 1, remaining_queries = remaining_queries + 1 WHERE id = ?',
      [req.userInfo.id]
    );

    // 返回更新后的用户信息
    const [updatedUser] = await req.db.execute(
      'SELECT remaining_queries, share_count FROM user_info WHERE id = ?',
      [req.userInfo.id]
    );

    res.json({
      success: true,
      data: {
        remaining_queries: updatedUser[0].remaining_queries,
        share_count: updatedUser[0].share_count
      }
    });
  } catch (error) {
    console.error('分享奖励错误：', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});

// 好友分享奖励接口
// 处理好友分享链接的奖励，为分享者和接收者各增加5次查询次数
router.post('/share/reward', verifyToken, async (req, res) => {
  try {
    // 验证请求参数
    const { sharer_id } = req.body;
    if (!sharer_id) {
      return res.status(400).json({ error: '缺少分享者ID参数' });
    }

    // 验证分享者ID是否存在
    const [sharer] = await req.db.execute(
      'SELECT id FROM user_info WHERE id = ?',
      [sharer_id]
    );

    if (!sharer || sharer.length === 0) {
      return res.status(404).json({ error: '分享者不存在' });
    }

    // 验证接收者不是分享者本人
    if (String(req.userInfo.id) === String(sharer_id)) {
      return res.status(400).json({ error: '不能给自己增加奖励' });
    }

    // 开启事务
    const connection = await req.db.getConnection();
    await connection.beginTransaction();

    try {
      // 为分享者增加5次查询次数
      await connection.execute(
        'UPDATE user_info SET remaining_queries = remaining_queries + 5 WHERE id = ?',
        [sharer_id]
      );

      // 为接收者增加5次查询次数
      await connection.execute(
        'UPDATE user_info SET remaining_queries = remaining_queries + 5 WHERE id = ?',
        [req.userInfo.id]
      );

      // 提交事务
      await connection.commit();

      // 获取更新后的查询次数
      const [updatedUser] = await req.db.execute(
        'SELECT remaining_queries FROM user_info WHERE id = ?',
        [req.userInfo.id]
      );

      res.json({
        success: true,
        data: {
          remaining_queries: updatedUser[0].remaining_queries
        }
      });
    } catch (error) {
      // 如果出错，回滚事务
      await connection.rollback();
      throw error;
    } finally {
      // 释放连接
      connection.release();
    }
  } catch (error) {
    console.error('好友分享奖励错误：', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});

// 获取用户信息接口
// 根据token获取用户的基本信息，包括ID、剩余查询次数和总查询次数
router.get('/user/info', verifyToken, async (req, res) => {
  try {
    // 从req.userInfo中获取用户信息
    // verifyToken中间件已经查询了用户信息并添加到req对象中
    const { id, remaining_queries, total_queries, share_count } = req.userInfo;

    // 返回用户信息
    res.json({
      success: true,
      data: {
        user_id: id,
        remaining_queries,
        total_queries,
        share_count
      }
    });
  } catch (error) {
    console.error('获取用户信息错误：', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});

module.exports = router;